/**
 * 研发项目管理模块入口文件
 * 负责导出所有研发管理相关的模块
 */

// 导入所有模块
const BaseFileManager = require('./base_file_manager');
const ResourceManager = require('./resource_manager');
const FlowManager = require('./flow_manager');
const BranchManager = require('./branch_manager');
const DocManager = require('./doc_manager');
const UIManager = require('./ui_manager');

// 导入辅助工具 - 添加这一行确保依赖正确
const pageHelper = require('./helpers/page_helper.js');

/**
 * 研发管理类
 * 用于统一管理研发项目的各个功能模块
 */
export class ResearchManagement {
  /**
   * 构造函数
   * @param {Object} page - 页面实例
   * @param {Object} options - 配置选项
   */
  constructor(page, options = {}) {
    this.page = page;
    this.options = options;
    
    // 实例化各个模块
    this.resourceManager = new ResourceManager(page, options);
    this.flowManager = new FlowManager(page, options.stateMachineStore);
    this.branchManager = new BranchManager(page, options);
    this.docManager = new DocManager(page, options);
    this.uiManager = new UIManager(page);
  }

  /**
   * 初始化研发管理
   * @param {Object} project - 项目信息
   * @param {string} currentRole - 当前用户角色
   */
  init(project, currentRole) {
    if (!project) return;
    
    // 初始化各个模块
    this.uiManager.initUI();
    this.flowManager.init(project, currentRole);
    
    // 设置项目信息
    this.project = project;
    this.currentRole = currentRole;
  }

  /**
   * 加载项目分支
   * @param {string} projectId - 项目ID
   * @returns {Promise<Array>} 分支项目列表
   */
  async loadBranches(projectId) {
    return this.branchManager.getBranchProjects(projectId);
  }

  /**
   * 加载项目资源
   * @param {string} projectId - 项目ID
   * @returns {Promise<Array>} 资源列表
   */
  async loadResources(projectId) {
    // 获取资源版本列表
    const resourceVersions = await this.resourceManager.getResourceVersionList(projectId);
    
    // 获取最新版本的资源
    const latestResources = this.resourceManager.getLatestResourceVersions(resourceVersions);
    
    // 处理资源数据
    const folders = this.resourceManager.initResourceFolders();
    const processedFolders = this.resourceManager.processResourceData(folders, latestResources);
    
    // 更新页面数据
    if (this.page && this.page.setData) {
      this.page.setData({
        resourceVersions,
        resourceFolders: processedFolders
      });
    }
    
    return {
      resourceVersions,
      processedFolders
    };
  }

  /**
   * 加载项目文档
   * @param {string} projectId - 项目ID
   * @returns {Promise<Array>} 文档列表
   */
  async loadDocuments(projectId) {
    try {
      const documents = await this.docManager.getDocuments(projectId);
      
      // 更新页面数据
      if (this.page && this.page.setData) {
        this.page.setData({
          documents
        });
      }
      
      return documents;
    } catch (error) {
      this.uiManager.showError('加载文档失败：' + error.message);
      return [];
    }
  }

  /**
   * 加载项目流程历史
   * @param {string} projectId - 项目ID
   * @returns {Promise<Array>} 流程历史记录
   */
  async loadFlowHistory(projectId) {
    try {
      const flowHistory = await this.flowManager.getFlowHistory(projectId);
      
      // 更新页面数据
      if (this.page && this.page.setData) {
        this.page.setData({
          flowHistory
        });
      }
      
      return flowHistory;
    } catch (error) {
      this.uiManager.showError('加载流程历史失败：' + error.message);
      return [];
    }
  }

  /**
   * 上传资源文件
   * @param {Object} resource - 资源信息
   * @returns {Promise<Object>} 上传结果
   */
  async uploadResource(resource) {
    try {
      return await this.resourceManager.uploadResource(resource);
    } catch (error) {
      this.uiManager.showError('上传资源失败：' + error.message);
      throw error;
    }
  }

  /**
   * 上传文档
   * @param {Object} doc - 文档信息
   * @returns {Promise<Object>} 上传结果
   */
  async uploadDoc(doc) {
    try {
      return await this.docManager.uploadDoc(doc);
    } catch (error) {
      this.uiManager.showError('上传文档失败：' + error.message);
      throw error;
    }
  }

  /**
   * 提交状态转换
   * @param {Object} params - 状态转换参数
   * @returns {Promise<Object>} 状态转换结果
   */
  async submitStateTransition(params) {
    try {
      return await this.flowManager.submitStateTransition(params);
    } catch (error) {
      this.uiManager.showError('提交状态转换失败：' + error.message);
      throw error;
    }
  }

  /**
   * 创建分支项目
   * @param {Object} params - 分支创建参数
   * @returns {Promise<Object>} 创建结果
   */
  async createBranch(params) {
    try {
      return await this.branchManager.createBranch(params);
    } catch (error) {
      this.uiManager.showError('创建分支失败：' + error.message);
      throw error;
    }
  }

  /**
   * 切换文件夹
   * @param {string} folderId - 文件夹ID
   */
  switchFolder(folderId) {
    this.uiManager.switchFolder(folderId);
  }

  /**
   * 切换标签页
   * @param {number} tabIndex - 标签页索引
   */
  switchTab(tabIndex) {
    this.uiManager.switchTab(tabIndex);
  }

  /**
   * 切换标签分类
   * @param {string} category - 标签分类 (static/dynamic)
   */
  switchTabCategory(category) {
    this.uiManager.switchTabCategory(category);
  }

  /**
   * 预览资源文件
   * @param {Object} resource - 资源对象
   */
  async viewResource(resource) {
    try {
      await this.resourceManager.viewResource(resource);
    } catch (error) {
      this.uiManager.showError('预览资源失败：' + error.message);
    }
  }

  /**
   * 预览文档
   * @param {Object} doc - 文档对象
   */
  async viewDoc(doc) {
    try {
      await this.docManager.viewDoc(doc);
    } catch (error) {
      this.uiManager.showError('预览文档失败：' + error.message);
    }
  }

  /**
   * 下载资源文件
   * @param {Object} resource - 资源对象
   */
  async downloadResource(resource) {
    try {
      await this.resourceManager.downloadResource(resource);
    } catch (error) {
      this.uiManager.showError('下载资源失败：' + error.message);
    }
  }

  /**
   * 下载文档
   * @param {Object} doc - 文档对象
   */
  async downloadDoc(doc) {
    try {
      await this.docManager.downloadDoc(doc);
    } catch (error) {
      this.uiManager.showError('下载文档失败：' + error.message);
    }
  }

  /**
   * 批量下载资源
   * @param {Array} resources - 资源列表
   */
  async batchDownloadResources(resources) {
    try {
      await this.resourceManager.batchDownloadResources(resources);
    } catch (error) {
      this.uiManager.showError('批量下载资源失败：' + error.message);
    }
  }

  /**
   * 批量下载文档
   * @param {Array} docs - 文档列表
   */
  async batchDownloadDocs(docs) {
    try {
      await this.docManager.batchDownloadDocs(docs);
    } catch (error) {
      this.uiManager.showError('批量下载文档失败：' + error.message);
    }
  }

  /**
   * 删除资源
   * @param {string} resourceId - 资源ID
   * @param {string} projectId - 项目ID
   * @returns {Promise<boolean>} 是否删除成功
   */
  async deleteResource(resourceId, projectId) {
    try {
      return await this.resourceManager.deleteResource(resourceId, projectId);
    } catch (error) {
      this.uiManager.showError('删除资源失败：' + error.message);
      return false;
    }
  }

  /**
   * 删除文档
   * @param {string} docId - 文档ID
   * @param {string} projectId - 项目ID
   * @returns {Promise<boolean>} 是否删除成功
   */
  async deleteDoc(docId, projectId) {
    try {
      return await this.docManager.deleteDoc(docId, projectId);
    } catch (error) {
      this.uiManager.showError('删除文档失败：' + error.message);
      return false;
    }
  }

  /**
   * 获取项目进度
   * @param {Object} project - 项目信息
   * @returns {number} 项目进度(0-100)
   */
  getProjectProgress(project) {
    return this.flowManager.getProjectProgress(project || this.project);
  }

  /**
   * 获取未完成项目
   * @param {Object} project - 项目信息
   * @returns {Array} 未完成项目列表
   */
  getUnfinishedItems(project) {
    return this.flowManager.getUnfinishedItems(project || this.project);
  }

  /**
   * 检查用户是否有流转权限
   * @param {Object} project - 项目信息
   * @param {string} userRole - 用户角色
   * @returns {boolean} 是否有流转权限
   */
  checkFlowPermission(project, userRole) {
    return this.flowManager.checkFlowPermission(
      project || this.project, 
      userRole || this.currentRole
    );
  }
}

// 同时支持CommonJS模块导出
module.exports = { ResearchManagement }; 